C++ Primer, Fifth Edition: The Mechanics of Copy Control

To master the life cycle of a C++ object is to command the very mechanics of existence within the heap and stack. Copy control defines how a class manages its lifetime through two operations: the copy constructor and the copy-assignment operator.

1. Initialization vs. Assignment

Direct initialization (e.g., string dots(10, '.')) invokes a constructor directly. However, copy initialization (string s2 = dots) relies on the copy constructor. Unlike initialization, assignment (trans = accum) overwrites an existing object using operator=. A critical constraint: the copy constructor's parameter must be a reference (const Foo&); otherwise, passing an argument by value would trigger an infinite recursive loop of copy calls.

2. The Role of Synthesis

If you don't define these members, the compiler provides synthesized versions that perform memberwise copies. Beware: while sufficient for simple types, these often fail for classes managing dynamic memory, leading to dangling pointers or double-frees.

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

Why must the first parameter of a copy constructor be a reference type (usually const)?

To allow the compiler to optimize the code into a move operation.

To prevent infinite recursion during parameter initialization.

Because pointers are not allowed in constructor signatures.

To ensure the object is placed on the heap rather than the stack.

QUESTION 2

What is the primary difference between Copy Initialization and Direct Initialization?

Direct initialization uses the assignment operator; copy initialization does not.

Copy initialization always requires the 'new' keyword.

Direct initialization asks the compiler to find the best constructor; copy initialization requires the copy constructor.

There is no functional difference; they are just different syntax for the same call.

QUESTION 3

Assume 'numbered' has a synthesized copy constructor that copies a unique ID 'mysn'. What happens if you run: numbered a, b = a, c = b;?

Each object (a, b, c) will have a unique 'mysn' value.

The program will fail to compile because IDs cannot be copied.

All three objects will share the exact same 'mysn' value.

Object 'a' will be reset to zero after the copy.

QUESTION 4

Which of the following would trigger a compilation error if the constructor 'vector<int>(int size)' is marked 'explicit'?

vector<int> v(10);

vector<int> v = 10;

f(vector<int>(10));

vector<int>* p = new vector<int>(10);

QUESTION 5

What should a well-behaved copy-assignment operator usually return?

void

A copy of the current object by value.

A reference to the left-hand operand (*this).

The memory address of the right-hand operand.

Case Study: Identifying Copy Logistics

Trace object construction and assignment

Analyze the following snippet: Point global; Point foo_bar(Point arg) { Point local = arg; Point *heap = new Point(global); *heap = local; Point pa[2] = { local, *heap }; return *heap; }

1. How many times is the copy constructor called in the execution of foo_bar?

Solution:
The copy constructor is called 6 times: 1. Passing 'arg' by value. 2. Initializing 'local'. 3. Dynamic construction of '*heap' from 'global'. 4. Initializing pa[0]. 5. Initializing pa[1]. 6. Initializing the return value from '*heap'.

2. Does the line '*heap = local' use the copy constructor?

Solution:
No. This is an assignment operation on an already existing object pointed to by 'heap'. It uses the copy-assignment operator (operator=), not the copy constructor.

3. If the 'Message' class used synthesized copy control while managing a list of 'Folders', what potential danger arises?

Solution:
A 'shallow copy' would occur. The new 'Message' would point to the same internal resources as the old one, but the 'Folders' wouldn't know about the new message. This leads to broken links or double-free errors when the messages are destroyed.